home *** CD-ROM | disk | FTP | other *** search
/ Multimedia Jumpstart / Multimedia Microsoft Jumpstart Version 1.1a (Microsoft).BIN / develpmt / sdk / vfw11.win / vfwdk / acmthunk.c_ / acmthunk.bin
Encoding:
Text File  |  1993-11-19  |  33.9 KB  |  1,289 lines
  1. //==========================================================================;
  2. //
  3. //  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  4. //  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  5. //  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  6. //  PURPOSE.
  7. //
  8. //  Copyright (c) 1992, 1993  Microsoft Corporation.  All Rights Reserved.
  9. //
  10. //--------------------------------------------------------------------------;
  11. //
  12. //  acmthunk.c
  13. //
  14. //  Description:
  15. //      This is a thunk layer to the Audio Compression Manager. It's 
  16. //      purpose is to allow an application to use the ACM only if it is
  17. //      available (like under Win 3.1 and NT where the ACM may or may not
  18. //      be installed).
  19. //
  20. //      There are two requirements for using this module:
  21. //
  22. //      1.  Compile and link with this module before linking to MMSYSTEM.LIB.
  23. //          Do *NOT* link with MSACM.LIB.
  24. //
  25. //      2.  Before calling any other functions in ACM function set, call
  26. //          acmThunkInitialize(). This will cause all dyna-linking to occur.
  27. //
  28. //      3.  Before exiting your application, call acmThunkTerminate().
  29. //          This will unlink to the ACM and free allocated resources.
  30. //
  31. //      NOTE! this could be written more efficiently in Assembly by doing
  32. //      a jump to the correct API in the ACM, but this would not be
  33. //      portable (easily) on NT. So the arguments will be repushed on the
  34. //      stack.. such is life.
  35. //
  36. //==========================================================================;
  37.  
  38. #include <windows.h>
  39. #include <windowsx.h>
  40. #include <mmsystem.h>
  41. #include <mmreg.h>
  42. #include <msacm.h>
  43.  
  44. //
  45. //
  46. //
  47. #ifdef WIN32
  48.     #define BCODE
  49. #else
  50.     #define BCODE           _based(_segname("_CODE"))
  51. #endif
  52.  
  53.  
  54. //==========================================================================;
  55. //
  56. //  Prototypes and String Defines for Dyna-Linking to the ACM
  57. //
  58. //
  59. //==========================================================================;
  60.  
  61. #define ACMINST_NOT_PRESENT     NULL
  62. #define ACMINST_TRY_LINKING     (HINSTANCE)(UINT)-1
  63.  
  64. static HINSTANCE    ghinstAcm   = ACMINST_TRY_LINKING;
  65.  
  66. #ifdef WIN32
  67. TCHAR BCODE gszAcmModuleName[]  = TEXT("MSACM32.DLL");
  68. #else
  69. char BCODE  gszAcmModuleName[]  = "MSACM.DLL";
  70. #endif
  71.  
  72. FARPROC    *gpafnAcmFunctions;
  73.  
  74. PSTR BCODE  gapszAcmFunctions[] =
  75. {
  76.     "acmGetVersion",
  77.     "acmMetrics",
  78.     "acmDriverEnum",
  79.     "acmDriverDetails",
  80.     "acmDriverAdd",
  81.     "acmDriverRemove",
  82.     "acmDriverOpen",
  83.     "acmDriverClose",
  84.     "acmDriverMessage",
  85.     "acmDriverID",
  86.     "acmDriverPriority",
  87.     "acmFormatTagDetails",
  88.     "acmFormatTagEnum",
  89.     "acmFormatChoose",
  90.     "acmFormatDetails",
  91.     "acmFormatEnum",
  92.     "acmFormatSuggest",
  93.     "acmFilterTagDetails",
  94.     "acmFilterTagEnum",
  95.     "acmFilterChoose",
  96.     "acmFilterDetails",
  97.     "acmFilterEnum",
  98.     "acmStreamOpen",
  99.     "acmStreamClose",
  100.     "acmStreamSize",
  101.     "acmStreamConvert",
  102.     "acmStreamReset",
  103.     "acmStreamPrepareHeader",
  104.     "acmStreamUnprepareHeader"
  105. };
  106.  
  107. #define ACMTHUNK_MAX_FUNCTIONS      (sizeof(gapszAcmFunctions)/sizeof(gapszAcmFunctions[0]))
  108. #define ACMTHUNK_SIZE_TABLE_BYTES   (ACMTHUNK_MAX_FUNCTIONS * sizeof(FARPROC))
  109.  
  110. #define ACMTHUNK_GETVERSION             0
  111. #define ACMTHUNK_METRICS                1
  112. #define ACMTHUNK_DRIVERENUM             2
  113. #define ACMTHUNK_DRIVERDETAILS          3
  114. #define ACMTHUNK_DRIVERADD              4
  115. #define ACMTHUNK_DRIVERREMOVE           5
  116. #define ACMTHUNK_DRIVEROPEN             6
  117. #define ACMTHUNK_DRIVERCLOSE            7
  118. #define ACMTHUNK_DRIVERMESSAGE          8
  119. #define ACMTHUNK_DRIVERID               9
  120. #define ACMTHUNK_DRIVERPRIORITY         10
  121. #define ACMTHUNK_FORMATTAGDETAILS       11
  122. #define ACMTHUNK_FORMATTAGENUM          12
  123. #define ACMTHUNK_FORMATCHOOSE           13
  124. #define ACMTHUNK_FORMATDETAILS          14
  125. #define ACMTHUNK_FORMATENUM             15
  126. #define ACMTHUNK_FORMATSUGGEST          16
  127. #define ACMTHUNK_FILTERTAGDETAILS       17
  128. #define ACMTHUNK_FILTERTAGENUM          18
  129. #define ACMTHUNK_FILTERCHOOSE           19
  130. #define ACMTHUNK_FILTERDETAILS          20
  131. #define ACMTHUNK_FILTERENUM             21
  132. #define ACMTHUNK_STREAMOPEN             22
  133. #define ACMTHUNK_STREAMCLOSE            23
  134. #define ACMTHUNK_STREAMSIZE             24
  135. #define ACMTHUNK_STREAMCONVERT          25
  136. #define ACMTHUNK_STREAMRESET            26
  137. #define ACMTHUNK_STREAMPREPAREHEADER    27
  138. #define ACMTHUNK_STREAMUNPREPAREHEADER  28
  139.  
  140.  
  141. //==========================================================================;
  142. //
  143. //
  144. //
  145. //==========================================================================;
  146.  
  147. //--------------------------------------------------------------------------;
  148. //  
  149. //  BOOL acmThunkInitialize
  150. //  
  151. //  Description:
  152. //  
  153. //  
  154. //  Arguments:
  155. //      None.
  156. //  
  157. //  Return (BOOL):
  158. //  
  159. //--------------------------------------------------------------------------;
  160.  
  161. BOOL FAR PASCAL acmThunkInitialize
  162. (
  163.     void
  164. )
  165. {
  166.     DWORD (ACMAPI *pfnAcmGetVersion)
  167.     (
  168.         void
  169.     );
  170.  
  171.     UINT            fuErrorMode;
  172.     DWORD           dwVersion;
  173.     UINT            u;
  174.  
  175.     //
  176.     //  if we have already linked to the API's, then just succeed...
  177.     //
  178.     if (NULL != gpafnAcmFunctions)
  179.     {
  180.         //
  181.         //  someone isn't satisfied with calling this API only once?
  182.         //
  183.         return (TRUE);
  184.     }
  185.  
  186.  
  187.     //
  188.     //  if we have already tried to link to the ACM, then fail this
  189.     //  call--it isn't present.
  190.     //
  191.     if (ACMINST_TRY_LINKING != ghinstAcm)
  192.         return (FALSE);
  193.  
  194.  
  195.     //
  196.     //  try to get a handle on the ACM--if we cannot do this, then fail
  197.     //
  198.     fuErrorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX);
  199.     ghinstAcm = LoadLibrary(gszAcmModuleName);
  200.     SetErrorMode(fuErrorMode);
  201.     if (ghinstAcm < HINSTANCE_ERROR)
  202.     {
  203.         ghinstAcm = ACMINST_NOT_PRESENT;
  204.         return (FALSE);
  205.     }
  206.  
  207.     (FARPROC)pfnAcmGetVersion = GetProcAddress(ghinstAcm, gapszAcmFunctions[ACMTHUNK_GETVERSION]);
  208.     if (NULL == pfnAcmGetVersion)
  209.     {
  210.         FreeLibrary(ghinstAcm);
  211.         ghinstAcm = ACMINST_NOT_PRESENT;
  212.  
  213.         return (FALSE);
  214.     }
  215.  
  216.  
  217.     //
  218.     //  allocate our array of function pointers to the ACM... note that
  219.     //  this is dynamically allocated so if the ACM is _not_ present,
  220.     //  then this code and data takes up very little space.
  221.     //
  222.     gpafnAcmFunctions = (FARPROC *)LocalAlloc(LPTR, ACMTHUNK_SIZE_TABLE_BYTES);
  223.     if (NULL == gpafnAcmFunctions)
  224.     {
  225.         FreeLibrary(ghinstAcm);
  226.         ghinstAcm = ACMINST_NOT_PRESENT;
  227.  
  228.         return (FALSE);
  229.     }
  230.  
  231.     gpafnAcmFunctions[ACMTHUNK_GETVERSION] = (FARPROC)pfnAcmGetVersion;
  232.  
  233.     //
  234.     //  if the version of the ACM is *NOT* V2.00 or greater, then
  235.     //  all other API's are unavailable--so don't waste time trying
  236.     //  to link to them.
  237.     //
  238.     dwVersion = (* pfnAcmGetVersion)();
  239.     if (0x0200 > HIWORD(dwVersion))
  240.     {
  241.         return (TRUE);
  242.     }
  243.  
  244.  
  245.     //
  246.     //  yipee! the ACM V2.00 or greater appears to be installed and
  247.     //  happy with us--so link to the rest of the nifty cool API's.
  248.     //
  249.     //  start at index 1 since we already linked to acmGetVersion above
  250.     //
  251.     for (u = 1; u < ACMTHUNK_MAX_FUNCTIONS; u++)
  252.     {
  253.         gpafnAcmFunctions[u] = GetProcAddress(ghinstAcm, gapszAcmFunctions[u]);
  254.     }
  255.  
  256.  
  257.     //
  258.     //  finally, return success
  259.     //
  260.     return (TRUE);
  261. } // acmThunkInitialize()
  262.  
  263.  
  264. //--------------------------------------------------------------------------;
  265. //  
  266. //  BOOL acmThunkTerminate
  267. //  
  268. //  Description:
  269. //  
  270. //  
  271. //  Arguments:
  272. //      None.
  273. //  
  274. //  Return (BOOL):
  275. //  
  276. //--------------------------------------------------------------------------;
  277.  
  278. BOOL FAR PASCAL acmThunkTerminate
  279. (
  280.     void
  281. )
  282. {
  283.     //
  284.     //
  285.     //
  286.     if (NULL != gpafnAcmFunctions)
  287.     {
  288.         LocalFree((HLOCAL)gpafnAcmFunctions);
  289.  
  290.         gpafnAcmFunctions = NULL;
  291.  
  292.         FreeLibrary(ghinstAcm);
  293.         ghinstAcm = ACMINST_TRY_LINKING;
  294.     }
  295.  
  296.     return (TRUE);
  297. } // acmThunkTerminate()
  298.  
  299.  
  300. //==========================================================================;
  301. //
  302. //  General Information API's
  303. //
  304. //
  305. //==========================================================================;
  306.  
  307. DWORD ACMAPI acmGetVersion
  308. (
  309.     void
  310. )
  311. {
  312.     DWORD (ACMAPI *pfnAcmGetVersion)
  313.     (
  314.         void
  315.     );
  316.  
  317.     DWORD           dwVersion;
  318.  
  319.     if (NULL == gpafnAcmFunctions)
  320.         return (0L);
  321.  
  322.     (FARPROC)pfnAcmGetVersion = gpafnAcmFunctions[ACMTHUNK_GETVERSION];
  323.     if (NULL == pfnAcmGetVersion)
  324.         return (0L);
  325.  
  326.     dwVersion = (* pfnAcmGetVersion)();
  327.  
  328.     return (dwVersion);
  329. } // acmGetVersion()
  330.  
  331.  
  332. //--------------------------------------------------------------------------;
  333. //--------------------------------------------------------------------------;
  334.  
  335. MMRESULT ACMAPI acmMetrics
  336. (
  337.     HACMOBJ                 hao,
  338.     UINT                    uMetric,
  339.     LPVOID                  pMetric
  340. )
  341. {
  342.     MMRESULT (ACMAPI *pfnAcmMetrics)
  343.     (
  344.         HACMOBJ                 hao,
  345.         UINT                    uMetric,
  346.         LPVOID                  pMetric
  347.     );
  348.  
  349.     MMRESULT        mmr;
  350.  
  351.     if (NULL == gpafnAcmFunctions)
  352.         return (MMSYSERR_ERROR);
  353.  
  354.     (FARPROC)pfnAcmMetrics = gpafnAcmFunctions[ACMTHUNK_METRICS];
  355.     if (NULL == pfnAcmMetrics)
  356.         return (MMSYSERR_ERROR);
  357.  
  358.     mmr = (* pfnAcmMetrics)(hao, uMetric, pMetric);
  359.  
  360.     return (mmr);
  361. } // acmMetrics()
  362.  
  363.  
  364. //==========================================================================;
  365. //
  366. //  ACM Driver Management API's
  367. //
  368. //
  369. //==========================================================================;
  370.  
  371. //--------------------------------------------------------------------------;
  372. //--------------------------------------------------------------------------;
  373.  
  374. MMRESULT ACMAPI acmDriverEnum
  375. (
  376.     ACMDRIVERENUMCB         fnCallback,
  377.     DWORD                   dwInstance,
  378.     DWORD                   fdwEnum
  379. )
  380. {
  381.     MMRESULT (ACMAPI *pfnAcmDriverEnum)
  382.     (
  383.         ACMDRIVERENUMCB         fnCallback,
  384.         DWORD                   dwInstance,
  385.         DWORD                   fdwEnum
  386.     );
  387.  
  388.     MMRESULT        mmr;
  389.  
  390.     if (NULL == gpafnAcmFunctions)
  391.         return (MMSYSERR_ERROR);
  392.  
  393.     (FARPROC)pfnAcmDriverEnum = gpafnAcmFunctions[ACMTHUNK_DRIVERENUM];
  394.     if (NULL == pfnAcmDriverEnum)
  395.         return (MMSYSERR_ERROR);
  396.  
  397.     mmr = (* pfnAcmDriverEnum)(fnCallback, dwInstance, fdwEnum);
  398.  
  399.     return (mmr);
  400. }
  401.  
  402.  
  403. //--------------------------------------------------------------------------;
  404. //--------------------------------------------------------------------------;
  405.  
  406. MMRESULT ACMAPI acmDriverDetails
  407. (
  408.     HACMDRIVERID            hadid,
  409.     LPACMDRIVERDETAILS      padd,
  410.     DWORD                   fdwDetails
  411. )
  412. {
  413.     MMRESULT (ACMAPI *pfnAcmDriverDetails)
  414.     (
  415.         HACMDRIVERID            hadid,
  416.         LPACMDRIVERDETAILS      padd,
  417.         DWORD                   fdwDetails
  418.     );
  419.  
  420.     MMRESULT        mmr;
  421.  
  422.     if (NULL == gpafnAcmFunctions)
  423.         return (MMSYSERR_ERROR);
  424.  
  425.     (FARPROC)pfnAcmDriverDetails = gpafnAcmFunctions[ACMTHUNK_DRIVERDETAILS];
  426.     if (NULL == pfnAcmDriverDetails)
  427.         return (MMSYSERR_ERROR);
  428.  
  429.     mmr = (* pfnAcmDriverDetails)(hadid, padd, fdwDetails);
  430.  
  431.     return (mmr);
  432. }
  433.  
  434.  
  435. //--------------------------------------------------------------------------;
  436. //--------------------------------------------------------------------------;
  437.  
  438. MMRESULT ACMAPI acmDriverAdd
  439. (
  440.     LPHACMDRIVERID          phadid,
  441.     HINSTANCE               hinstModule,
  442.     LPARAM                  lParam, 
  443.     DWORD                   dwPriority,
  444.     DWORD                   fdwAdd
  445. )
  446. {
  447.     MMRESULT (ACMAPI *pfnAcmDriverAdd)
  448.     (
  449.         LPHACMDRIVERID          phadid,
  450.         HINSTANCE               hinstModule,
  451.         LPARAM                  lParam, 
  452.         DWORD                   dwPriority,
  453.         DWORD                   fdwAdd
  454.     );
  455.  
  456.     MMRESULT        mmr;
  457.  
  458.     if (NULL == gpafnAcmFunctions)
  459.         return (MMSYSERR_ERROR);
  460.  
  461.     (FARPROC)pfnAcmDriverAdd = gpafnAcmFunctions[ACMTHUNK_DRIVERADD];
  462.     if (NULL == pfnAcmDriverAdd)
  463.         return (MMSYSERR_ERROR);
  464.  
  465.     mmr = (* pfnAcmDriverAdd)(phadid, hinstModule, lParam, dwPriority, fdwAdd);
  466.  
  467.     return (mmr);
  468. }
  469.  
  470.  
  471. //--------------------------------------------------------------------------;
  472. //--------------------------------------------------------------------------;
  473.  
  474. MMRESULT ACMAPI acmDriverRemove
  475. (
  476.     HACMDRIVERID            hadid,
  477.     DWORD                   fdwRemove
  478. )
  479. {
  480.     MMRESULT (ACMAPI *pfnAcmDriverRemove)
  481.     (
  482.         HACMDRIVERID            hadid,
  483.         DWORD                   fdwRemove
  484.     );
  485.  
  486.     MMRESULT        mmr;
  487.  
  488.     if (NULL == gpafnAcmFunctions)
  489.         return (MMSYSERR_ERROR);
  490.  
  491.     (FARPROC)pfnAcmDriverRemove = gpafnAcmFunctions[ACMTHUNK_DRIVERREMOVE];
  492.     if (NULL == pfnAcmDriverRemove)
  493.         return (MMSYSERR_ERROR);
  494.  
  495.     mmr = (* pfnAcmDriverRemove)(hadid, fdwRemove);
  496.  
  497.     return (mmr);
  498. }
  499.  
  500.  
  501. //--------------------------------------------------------------------------;
  502. //--------------------------------------------------------------------------;
  503.  
  504. MMRESULT ACMAPI acmDriverOpen
  505. (
  506.     LPHACMDRIVER            phad, 
  507.     HACMDRIVERID            hadid,
  508.     DWORD                   fdwOpen
  509. )
  510. {
  511.     MMRESULT (ACMAPI *pfnAcmDriverOpen)
  512.     (
  513.         LPHACMDRIVER            phad, 
  514.         HACMDRIVERID            hadid,
  515.         DWORD                   fdwOpen
  516.     );
  517.  
  518.     MMRESULT        mmr;
  519.  
  520.     if (NULL == gpafnAcmFunctions)
  521.         return (MMSYSERR_ERROR);
  522.  
  523.     (FARPROC)pfnAcmDriverOpen = gpafnAcmFunctions[ACMTHUNK_DRIVEROPEN];
  524.     if (NULL == pfnAcmDriverOpen)
  525.         return (MMSYSERR_ERROR);
  526.  
  527.     mmr = (* pfnAcmDriverOpen)(phad, hadid, fdwOpen);
  528.  
  529.     return (mmr);
  530. }
  531.  
  532.  
  533. //--------------------------------------------------------------------------;
  534. //--------------------------------------------------------------------------;
  535.  
  536. MMRESULT ACMAPI acmDriverClose
  537. (
  538.     HACMDRIVER              had,
  539.     DWORD                   fdwClose
  540. )
  541. {
  542.     MMRESULT (ACMAPI *pfnAcmDriverClose)
  543.     (
  544.         HACMDRIVER              had,
  545.         DWORD                   fdwClose
  546.     );
  547.  
  548.     MMRESULT        mmr;
  549.  
  550.     if (NULL == gpafnAcmFunctions)
  551.         return (MMSYSERR_ERROR);
  552.  
  553.     (FARPROC)pfnAcmDriverClose = gpafnAcmFunctions[ACMTHUNK_DRIVERCLOSE];
  554.     if (NULL == pfnAcmDriverClose)
  555.         return (MMSYSERR_ERROR);
  556.  
  557.     mmr = (* pfnAcmDriverClose)(had, fdwClose);
  558.  
  559.     return (mmr);
  560. }
  561.  
  562.  
  563. //--------------------------------------------------------------------------;
  564. //--------------------------------------------------------------------------;
  565.  
  566. LRESULT ACMAPI acmDriverMessage
  567. (
  568.     HACMDRIVER              had,
  569.     UINT                    uMsg, 
  570.     LPARAM                  lParam1,
  571.     LPARAM                  lParam2
  572. )
  573. {
  574.     LRESULT (ACMAPI *pfnAcmDriverMessage)
  575.     (
  576.         HACMDRIVER              had,
  577.         UINT                    uMsg, 
  578.         LPARAM                  lParam1,
  579.         LPARAM                  lParam2
  580.     );
  581.  
  582.     LRESULT         lr;
  583.  
  584.     if (NULL == gpafnAcmFunctions)
  585.         return (MMSYSERR_ERROR);
  586.  
  587.     (FARPROC)pfnAcmDriverMessage = gpafnAcmFunctions[ACMTHUNK_DRIVERMESSAGE];
  588.     if (NULL == pfnAcmDriverMessage)
  589.         return (MMSYSERR_ERROR);
  590.  
  591.     lr = (* pfnAcmDriverMessage)(had, uMsg, lParam1, lParam2);
  592.  
  593.     return (lr);
  594. }
  595.  
  596.  
  597. //--------------------------------------------------------------------------;
  598. //--------------------------------------------------------------------------;
  599.  
  600. MMRESULT ACMAPI acmDriverID
  601. (
  602.     HACMOBJ                 hao,
  603.     LPHACMDRIVERID          phadid,
  604.     DWORD                   fdwDriverId
  605. )
  606. {
  607.     MMRESULT (ACMAPI *pfnAcmDriverId)
  608.     (
  609.         HACMOBJ                 hao,
  610.         LPHACMDRIVERID          phadid,
  611.         DWORD                   fdwDriverId
  612.     );
  613.  
  614.     MMRESULT        mmr;
  615.  
  616.     if (NULL == gpafnAcmFunctions)
  617.         return (MMSYSERR_ERROR);
  618.  
  619.     (FARPROC)pfnAcmDriverId = gpafnAcmFunctions[ACMTHUNK_DRIVERID];
  620.     if (NULL == pfnAcmDriverId)
  621.         return (MMSYSERR_ERROR);
  622.  
  623.     mmr = (* pfnAcmDriverId)(hao, phadid, fdwDriverId);
  624.  
  625.     return (mmr);
  626. }
  627.  
  628. //--------------------------------------------------------------------------;
  629. //--------------------------------------------------------------------------;
  630.  
  631. MMRESULT ACMAPI acmDriverPriority
  632. (
  633.     HACMDRIVERID            hadid,
  634.     DWORD                   dwPriority,
  635.     DWORD                   fdwPriority
  636. )
  637. {
  638.     MMRESULT (ACMAPI *pfnAcmDriverPriority)
  639.     (
  640.         HACMDRIVERID            hadid,
  641.         DWORD                   dwPriority,
  642.         DWORD                   fdwPriority
  643.     );
  644.  
  645.     MMRESULT        mmr;
  646.  
  647.     if (NULL == gpafnAcmFunctions)
  648.         return (MMSYSERR_ERROR);
  649.  
  650.     (FARPROC)pfnAcmDriverPriority = gpafnAcmFunctions[ACMTHUNK_DRIVERPRIORITY];
  651.     if (NULL == pfnAcmDriverPriority)
  652.         return (MMSYSERR_ERROR);
  653.  
  654.     mmr = (* pfnAcmDriverPriority)(hadid, dwPriority, fdwPriority);
  655.  
  656.     return (mmr);
  657. }
  658.  
  659.  
  660. //==========================================================================;
  661. //
  662. //  Format Tag Information API's
  663. //
  664. //
  665. //==========================================================================;
  666.  
  667. //--------------------------------------------------------------------------;
  668. //--------------------------------------------------------------------------;
  669.  
  670. MMRESULT ACMAPI acmFormatTagDetails
  671. (
  672.     HACMDRIVER              had,
  673.     LPACMFORMATTAGDETAILS   paftd,
  674.     DWORD                   fdwDetails
  675. )
  676. {
  677.     MMRESULT (ACMAPI *pfnAcmFormatTagDetails)
  678.     (
  679.         HACMDRIVER              had,
  680.         LPACMFORMATTAGDETAILS   paftd,
  681.         DWORD                   fdwDetails
  682.     );
  683.  
  684.     MMRESULT        mmr;
  685.  
  686.     if (NULL == gpafnAcmFunctions)
  687.         return (MMSYSERR_ERROR);
  688.  
  689.     (FARPROC)pfnAcmFormatTagDetails = gpafnAcmFunctions[ACMTHUNK_FORMATTAGDETAILS];
  690.     if (NULL == pfnAcmFormatTagDetails)
  691.         return (MMSYSERR_ERROR);
  692.  
  693.     mmr = (* pfnAcmFormatTagDetails)(had, paftd, fdwDetails);
  694.  
  695.     return (mmr);
  696. } // acmFormatTagDetails()
  697.  
  698.  
  699. //--------------------------------------------------------------------------;
  700. //--------------------------------------------------------------------------;
  701.  
  702. MMRESULT ACMAPI acmFormatTagEnum
  703. (
  704.     HACMDRIVER              had,
  705.     LPACMFORMATTAGDETAILS   paftd,
  706.     ACMFORMATTAGENUMCB      fnCallback,
  707.     DWORD                   dwInstance, 
  708.     DWORD                   fdwEnum
  709. )
  710. {
  711.     MMRESULT (ACMAPI *pfnAcmFormatTagEnum)
  712.     (
  713.         HACMDRIVER              had,
  714.         LPACMFORMATTAGDETAILS   paftd,
  715.         ACMFORMATTAGENUMCB      fnCallback,
  716.         DWORD                   dwInstance, 
  717.         DWORD                   fdwEnum
  718.     );
  719.  
  720.     MMRESULT        mmr;
  721.  
  722.     if (NULL == gpafnAcmFunctions)
  723.         return (MMSYSERR_ERROR);
  724.  
  725.     (FARPROC)pfnAcmFormatTagEnum = gpafnAcmFunctions[ACMTHUNK_FORMATTAGENUM];
  726.     if (NULL == pfnAcmFormatTagEnum)
  727.         return (MMSYSERR_ERROR);
  728.  
  729.     mmr = (* pfnAcmFormatTagEnum)(had, paftd, fnCallback, dwInstance, fdwEnum);
  730.  
  731.     return (mmr);
  732. } // acmFormatTagEnum()
  733.  
  734.  
  735. //==========================================================================;
  736. //
  737. //  Format Information API's
  738. //
  739. //
  740. //==========================================================================;
  741.  
  742. //--------------------------------------------------------------------------;
  743. //--------------------------------------------------------------------------;
  744.  
  745. MMRESULT ACMAPI acmFormatChoose
  746. (
  747.     LPACMFORMATCHOOSE       pafmtc
  748. )
  749. {
  750.     MMRESULT (ACMAPI *pfnAcmFormatChoose)
  751.     (
  752.         LPACMFORMATCHOOSE       pafmtc
  753.     );
  754.  
  755.     MMRESULT        mmr;
  756.  
  757.     if (NULL == gpafnAcmFunctions)
  758.         return (MMSYSERR_ERROR);
  759.  
  760.     (FARPROC)pfnAcmFormatChoose = gpafnAcmFunctions[ACMTHUNK_FORMATCHOOSE];
  761.     if (NULL == pfnAcmFormatChoose)
  762.         return (MMSYSERR_ERROR);
  763.  
  764.     mmr = (* pfnAcmFormatChoose)(pafmtc);
  765.  
  766.     return (mmr);
  767. }
  768.  
  769.  
  770. //--------------------------------------------------------------------------;
  771. //--------------------------------------------------------------------------;
  772.  
  773. MMRESULT ACMAPI acmFormatDetails
  774. (
  775.     HACMDRIVER              had,
  776.     LPACMFORMATDETAILS      pafd,
  777.     DWORD                   fdwDetails
  778. )
  779. {
  780.     MMRESULT (ACMAPI *pfnAcmFormatDetails)
  781.     (
  782.         HACMDRIVER              had,
  783.         LPACMFORMATDETAILS      pafd,
  784.         DWORD                   fdwDetails
  785.     );
  786.  
  787.     MMRESULT        mmr;
  788.  
  789.     if (NULL == gpafnAcmFunctions)
  790.         return (MMSYSERR_ERROR);
  791.  
  792.     (FARPROC)pfnAcmFormatDetails = gpafnAcmFunctions[ACMTHUNK_FORMATDETAILS];
  793.     if (NULL == pfnAcmFormatDetails)
  794.         return (MMSYSERR_ERROR);
  795.  
  796.     mmr = (* pfnAcmFormatDetails)(had, pafd, fdwDetails);
  797.  
  798.     return (mmr);
  799. } // acmFormatDetails()
  800.  
  801.  
  802. //--------------------------------------------------------------------------;
  803. //--------------------------------------------------------------------------;
  804.  
  805. MMRESULT ACMAPI acmFormatEnum
  806. (
  807.     HACMDRIVER              had,
  808.     LPACMFORMATDETAILS      pafd,
  809.     ACMFORMATENUMCB         fnCallback,
  810.     DWORD                   dwInstance, 
  811.     DWORD                   fdwEnum
  812. )
  813. {
  814.     MMRESULT (ACMAPI *pfnAcmFormatEnum)
  815.     (
  816.         HACMDRIVER              had,
  817.         LPACMFORMATDETAILS      pafd,
  818.         ACMFORMATENUMCB         fnCallback,
  819.         DWORD                   dwInstance, 
  820.         DWORD                   fdwEnum
  821.     );
  822.  
  823.     MMRESULT        mmr;
  824.  
  825.     if (NULL == gpafnAcmFunctions)
  826.         return (MMSYSERR_ERROR);
  827.  
  828.     (FARPROC)pfnAcmFormatEnum = gpafnAcmFunctions[ACMTHUNK_FORMATENUM];
  829.     if (NULL == pfnAcmFormatEnum)
  830.         return (MMSYSERR_ERROR);
  831.  
  832.     mmr = (* pfnAcmFormatEnum)(had, pafd, fnCallback, dwInstance, fdwEnum);
  833.  
  834.     return (mmr);
  835. }
  836.  
  837.  
  838. //--------------------------------------------------------------------------;
  839. //--------------------------------------------------------------------------;
  840.  
  841. MMRESULT ACMAPI acmFormatSuggest
  842. (
  843.     HACMDRIVER          had,
  844.     LPWAVEFORMATEX      pwfxSrc,
  845.     LPWAVEFORMATEX      pwfxDst,
  846.     DWORD               cbwfxDst,
  847.     DWORD               fdwSuggest
  848. )
  849. {
  850.     MMRESULT (ACMAPI *pfnAcmFormatSuggest)
  851.     (
  852.         HACMDRIVER          had,
  853.         LPWAVEFORMATEX      pwfxSrc,
  854.         LPWAVEFORMATEX      pwfxDst,
  855.         DWORD               cbwfxDst,
  856.         DWORD               fdwSuggest
  857.     );
  858.  
  859.     MMRESULT        mmr;
  860.  
  861.     if (NULL == gpafnAcmFunctions)
  862.         return (MMSYSERR_ERROR);
  863.  
  864.     (FARPROC)pfnAcmFormatSuggest = gpafnAcmFunctions[ACMTHUNK_FORMATSUGGEST];
  865.     if (NULL == pfnAcmFormatSuggest)
  866.         return (MMSYSERR_ERROR);
  867.  
  868.     mmr = (* pfnAcmFormatSuggest)(had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest);
  869.  
  870.     return (mmr);
  871. }
  872.  
  873.  
  874. //==========================================================================;
  875. //
  876. //  Filter Tag Information API's
  877. //
  878. //
  879. //==========================================================================;
  880.  
  881. //--------------------------------------------------------------------------;
  882. //--------------------------------------------------------------------------;
  883.  
  884. MMRESULT ACMAPI acmFilterTagDetails
  885. (
  886.     HACMDRIVER              had,
  887.     LPACMFILTERTAGDETAILS   paftd,
  888.     DWORD                   fdwDetails
  889. )
  890. {
  891.     MMRESULT (ACMAPI *pfnAcmFilterTagDetails)
  892.     (
  893.         HACMDRIVER              had,
  894.         LPACMFILTERTAGDETAILS   paftd,
  895.         DWORD                   fdwDetails
  896.     );
  897.  
  898.     MMRESULT        mmr;
  899.  
  900.     if (NULL == gpafnAcmFunctions)
  901.         return (MMSYSERR_ERROR);
  902.  
  903.     (FARPROC)pfnAcmFilterTagDetails = gpafnAcmFunctions[ACMTHUNK_FILTERTAGDETAILS];
  904.     if (NULL == pfnAcmFilterTagDetails)
  905.         return (MMSYSERR_ERROR);
  906.  
  907.     mmr = (* pfnAcmFilterTagDetails)(had, paftd, fdwDetails);
  908.  
  909.     return (mmr);
  910. } // acmFilterTagDetails()
  911.  
  912.  
  913. //--------------------------------------------------------------------------;
  914. //--------------------------------------------------------------------------;
  915.  
  916. MMRESULT ACMAPI acmFilterTagEnum
  917. (
  918.     HACMDRIVER              had,
  919.     LPACMFILTERTAGDETAILS   paftd,
  920.     ACMFILTERTAGENUMCB      fnCallback,
  921.     DWORD                   dwInstance, 
  922.     DWORD                   fdwEnum
  923. )
  924. {
  925.     MMRESULT (ACMAPI *pfnAcmFilterTagEnum)
  926.     (
  927.         HACMDRIVER              had,
  928.         LPACMFILTERTAGDETAILS   paftd,
  929.         ACMFILTERTAGENUMCB      fnCallback,
  930.         DWORD                   dwInstance, 
  931.         DWORD                   fdwEnum
  932.     );
  933.  
  934.     MMRESULT        mmr;
  935.  
  936.     if (NULL == gpafnAcmFunctions)
  937.         return (MMSYSERR_ERROR);
  938.  
  939.     (FARPROC)pfnAcmFilterTagEnum = gpafnAcmFunctions[ACMTHUNK_FILTERTAGENUM];
  940.     if (NULL == pfnAcmFilterTagEnum)
  941.         return (MMSYSERR_ERROR);
  942.  
  943.     mmr = (* pfnAcmFilterTagEnum)(had, paftd, fnCallback, dwInstance, fdwEnum);
  944.  
  945.     return (mmr);
  946. } // acmFilterTagEnum()
  947.  
  948.  
  949. //==========================================================================;
  950. //
  951. //  Filter Information API's
  952. //
  953. //
  954. //==========================================================================;
  955.  
  956. //--------------------------------------------------------------------------;
  957. //--------------------------------------------------------------------------;
  958.  
  959. MMRESULT ACMAPI acmFilterChoose
  960. (
  961.     LPACMFILTERCHOOSE       pafltrc
  962. )
  963. {
  964.     MMRESULT (ACMAPI *pfnAcmFilterChoose)
  965.     (
  966.         LPACMFILTERCHOOSE       pafltrc
  967.     );
  968.  
  969.     MMRESULT        mmr;
  970.  
  971.     if (NULL == gpafnAcmFunctions)
  972.         return (MMSYSERR_ERROR);
  973.  
  974.     (FARPROC)pfnAcmFilterChoose = gpafnAcmFunctions[ACMTHUNK_FILTERCHOOSE];
  975.     if (NULL == pfnAcmFilterChoose)
  976.         return (MMSYSERR_ERROR);
  977.  
  978.     mmr = (* pfnAcmFilterChoose)(pafltrc);
  979.  
  980.     return (mmr);
  981. }
  982.  
  983.  
  984. //--------------------------------------------------------------------------;
  985. //--------------------------------------------------------------------------;
  986.  
  987. MMRESULT ACMAPI acmFilterDetails
  988. (
  989.     HACMDRIVER              had,
  990.     LPACMFILTERDETAILS      pafd,
  991.     DWORD                   fdwDetails
  992. )
  993. {
  994.     MMRESULT (ACMAPI *pfnAcmFilterDetails)
  995.     (
  996.         HACMDRIVER              had,
  997.         LPACMFILTERDETAILS      pafd,
  998.         DWORD                   fdwDetails
  999.     );
  1000.  
  1001.     MMRESULT        mmr;
  1002.  
  1003.     if (NULL == gpafnAcmFunctions)
  1004.         return (MMSYSERR_ERROR);
  1005.  
  1006.     (FARPROC)pfnAcmFilterDetails = gpafnAcmFunctions[ACMTHUNK_FILTERDETAILS];
  1007.     if (NULL == pfnAcmFilterDetails)
  1008.         return (MMSYSERR_ERROR);
  1009.  
  1010.     mmr = (* pfnAcmFilterDetails)(had, pafd, fdwDetails);
  1011.  
  1012.     return (mmr);
  1013. } // acmFilterDetails()
  1014.  
  1015.  
  1016. //--------------------------------------------------------------------------;
  1017. //--------------------------------------------------------------------------;
  1018.  
  1019. MMRESULT ACMAPI acmFilterEnum
  1020. (
  1021.     HACMDRIVER              had,
  1022.     LPACMFILTERDETAILS      pafd,
  1023.     ACMFILTERENUMCB         fnCallback,
  1024.     DWORD                   dwInstance, 
  1025.     DWORD                   fdwEnum
  1026. )
  1027. {
  1028.     MMRESULT (ACMAPI *pfnAcmFilterEnum)
  1029.     (
  1030.         HACMDRIVER              had,
  1031.         LPACMFILTERDETAILS      pafd,
  1032.         ACMFILTERENUMCB         fnCallback,
  1033.         DWORD                   dwInstance, 
  1034.         DWORD                   fdwEnum
  1035.     );
  1036.  
  1037.     MMRESULT        mmr;
  1038.  
  1039.     if (NULL == gpafnAcmFunctions)
  1040.         return (MMSYSERR_ERROR);
  1041.  
  1042.     (FARPROC)pfnAcmFilterEnum = gpafnAcmFunctions[ACMTHUNK_FILTERENUM];
  1043.     if (NULL == pfnAcmFilterEnum)
  1044.         return (MMSYSERR_ERROR);
  1045.  
  1046.     mmr = (* pfnAcmFilterEnum)(had, pafd, fnCallback, dwInstance, fdwEnum);
  1047.  
  1048.     return (mmr);
  1049. }
  1050.  
  1051.  
  1052. //==========================================================================;
  1053. //
  1054. //  ACM Stream Management API's
  1055. //
  1056. //
  1057. //==========================================================================;
  1058.  
  1059. //--------------------------------------------------------------------------;
  1060. //--------------------------------------------------------------------------;
  1061.  
  1062. MMRESULT ACMAPI acmStreamOpen
  1063. (
  1064.     LPHACMSTREAM            phas,
  1065.     HACMDRIVER              had,
  1066.     LPWAVEFORMATEX          pwfxSrc,
  1067.     LPWAVEFORMATEX          pwfxDst,
  1068.     LPWAVEFILTER            pwfltr,
  1069.     DWORD                   dwCallback,
  1070.     DWORD                   dwInstance,
  1071.     DWORD                   fdwOpen
  1072. )
  1073. {
  1074.     MMRESULT (ACMAPI *pfnAcmStreamOpen)
  1075.     (
  1076.         LPHACMSTREAM            phas,
  1077.         HACMDRIVER              had,
  1078.         LPWAVEFORMATEX          pwfxSrc,
  1079.         LPWAVEFORMATEX          pwfxDst,
  1080.         LPWAVEFILTER            pwfltr,
  1081.         DWORD                   dwCallback,
  1082.         DWORD                   dwInstance,
  1083.         DWORD                   fdwOpen
  1084.     );
  1085.  
  1086.     MMRESULT        mmr;
  1087.  
  1088.     if (NULL == gpafnAcmFunctions)
  1089.         return (MMSYSERR_ERROR);
  1090.  
  1091.     (FARPROC)pfnAcmStreamOpen = gpafnAcmFunctions[ACMTHUNK_STREAMOPEN];
  1092.     if (NULL == pfnAcmStreamOpen)
  1093.         return (MMSYSERR_ERROR);
  1094.  
  1095.     mmr = (* pfnAcmStreamOpen)(phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
  1096.  
  1097.     return (mmr);
  1098. }
  1099.  
  1100.  
  1101. //--------------------------------------------------------------------------;
  1102. //--------------------------------------------------------------------------;
  1103.  
  1104. MMRESULT ACMAPI acmStreamClose
  1105. (
  1106.     HACMSTREAM              has,
  1107.     DWORD                   fdwClose
  1108. )
  1109. {
  1110.     MMRESULT (ACMAPI *pfnAcmStreamClose)
  1111.     (
  1112.         HACMSTREAM              has,
  1113.         DWORD                   fdwClose
  1114.     );
  1115.  
  1116.     MMRESULT        mmr;
  1117.  
  1118.     if (NULL == gpafnAcmFunctions)
  1119.         return (MMSYSERR_ERROR);
  1120.  
  1121.     (FARPROC)pfnAcmStreamClose = gpafnAcmFunctions[ACMTHUNK_STREAMCLOSE];
  1122.     if (NULL == pfnAcmStreamClose)
  1123.         return (MMSYSERR_ERROR);
  1124.  
  1125.     mmr = (* pfnAcmStreamClose)(has, fdwClose);
  1126.  
  1127.     return (mmr);
  1128. }
  1129.  
  1130.  
  1131. //--------------------------------------------------------------------------;
  1132. //--------------------------------------------------------------------------;
  1133.  
  1134. MMRESULT ACMAPI acmStreamSize
  1135. (
  1136.     HACMSTREAM              has,
  1137.     DWORD                   cbInput,
  1138.     LPDWORD                 pdwOutputBytes,
  1139.     DWORD                   fdwSize
  1140. )
  1141. {
  1142.     MMRESULT (ACMAPI *pfnAcmStreamSize)
  1143.     (
  1144.         HACMSTREAM              has,
  1145.         DWORD                   cbInput,
  1146.         LPDWORD                 pdwOutputBytes,
  1147.         DWORD                   fdwSize
  1148.     );
  1149.  
  1150.     MMRESULT        mmr;
  1151.  
  1152.     if (NULL == gpafnAcmFunctions)
  1153.         return (MMSYSERR_ERROR);
  1154.  
  1155.     (FARPROC)pfnAcmStreamSize = gpafnAcmFunctions[ACMTHUNK_STREAMSIZE];
  1156.     if (NULL == pfnAcmStreamSize)
  1157.         return (MMSYSERR_ERROR);
  1158.  
  1159.     mmr = (* pfnAcmStreamSize)(has, cbInput, pdwOutputBytes, fdwSize);
  1160.  
  1161.     return (mmr);
  1162. }
  1163.  
  1164.  
  1165. //--------------------------------------------------------------------------;
  1166. //--------------------------------------------------------------------------;
  1167.  
  1168. MMRESULT ACMAPI acmStreamConvert
  1169. (
  1170.     HACMSTREAM              has, 
  1171.     LPACMSTREAMHEADER       pash,
  1172.     DWORD                   fdwConvert
  1173. )
  1174. {
  1175.     MMRESULT (ACMAPI *pfnAcmStreamConvert)
  1176.     (
  1177.         HACMSTREAM              has, 
  1178.         LPACMSTREAMHEADER       pash,
  1179.         DWORD                   fdwConvert
  1180.     );
  1181.  
  1182.     MMRESULT        mmr;
  1183.  
  1184.     if (NULL == gpafnAcmFunctions)
  1185.         return (MMSYSERR_ERROR);
  1186.  
  1187.     (FARPROC)pfnAcmStreamConvert = gpafnAcmFunctions[ACMTHUNK_STREAMCONVERT];
  1188.     if (NULL == pfnAcmStreamConvert)
  1189.         return (MMSYSERR_ERROR);
  1190.  
  1191.     mmr = (* pfnAcmStreamConvert)(has, pash, fdwConvert);
  1192.  
  1193.     return (mmr);
  1194. }
  1195.  
  1196.  
  1197. //--------------------------------------------------------------------------;
  1198. //--------------------------------------------------------------------------;
  1199.  
  1200. MMRESULT ACMAPI acmStreamReset
  1201. (
  1202.     HACMSTREAM              has, 
  1203.     DWORD                   fdwReset
  1204. )
  1205. {
  1206.     MMRESULT (ACMAPI *pfnAcmStreamReset)
  1207.     (
  1208.         HACMSTREAM              has, 
  1209.         DWORD                   fdwReset
  1210.     );
  1211.  
  1212.     MMRESULT        mmr;
  1213.  
  1214.     if (NULL == gpafnAcmFunctions)
  1215.         return (MMSYSERR_ERROR);
  1216.  
  1217.     (FARPROC)pfnAcmStreamReset = gpafnAcmFunctions[ACMTHUNK_STREAMRESET];
  1218.     if (NULL == pfnAcmStreamReset)
  1219.         return (MMSYSERR_ERROR);
  1220.  
  1221.     mmr = (* pfnAcmStreamReset)(has, fdwReset);
  1222.  
  1223.     return (mmr);
  1224. }
  1225.  
  1226.  
  1227. //--------------------------------------------------------------------------;
  1228. //--------------------------------------------------------------------------;
  1229.  
  1230. MMRESULT ACMAPI acmStreamPrepareHeader
  1231. (
  1232.     HACMSTREAM              has, 
  1233.     LPACMSTREAMHEADER       pash,
  1234.     DWORD                   fdwPrepare
  1235. )
  1236. {
  1237.     MMRESULT (ACMAPI *pfnAcmStreamPrepareHeader)
  1238.     (
  1239.         HACMSTREAM              has, 
  1240.         LPACMSTREAMHEADER       pash,
  1241.         DWORD                   fdwPrepare
  1242.     );
  1243.  
  1244.     MMRESULT        mmr;
  1245.  
  1246.     if (NULL == gpafnAcmFunctions)
  1247.         return (MMSYSERR_ERROR);
  1248.  
  1249.     (FARPROC)pfnAcmStreamPrepareHeader = gpafnAcmFunctions[ACMTHUNK_STREAMPREPAREHEADER];
  1250.     if (NULL == pfnAcmStreamPrepareHeader)
  1251.         return (MMSYSERR_ERROR);
  1252.  
  1253.     mmr = (* pfnAcmStreamPrepareHeader)(has, pash, fdwPrepare);
  1254.  
  1255.     return (mmr);
  1256. }
  1257.  
  1258.  
  1259. //--------------------------------------------------------------------------;
  1260. //--------------------------------------------------------------------------;
  1261.  
  1262. MMRESULT ACMAPI acmStreamUnprepareHeader
  1263. (
  1264.     HACMSTREAM              has, 
  1265.     LPACMSTREAMHEADER       pash,
  1266.     DWORD                   fdwUnprepare
  1267. )
  1268. {
  1269.     MMRESULT (ACMAPI *pfnAcmStreamUnprepareHeader)
  1270.     (
  1271.         HACMSTREAM              has, 
  1272.         LPACMSTREAMHEADER       pash,
  1273.         DWORD                   fdwUnprepare
  1274.     );
  1275.  
  1276.     MMRESULT        mmr;
  1277.  
  1278.     if (NULL == gpafnAcmFunctions)
  1279.         return (MMSYSERR_ERROR);
  1280.  
  1281.     (FARPROC)pfnAcmStreamUnprepareHeader = gpafnAcmFunctions[ACMTHUNK_STREAMUNPREPAREHEADER];
  1282.     if (NULL == pfnAcmStreamUnprepareHeader)
  1283.         return (MMSYSERR_ERROR);
  1284.  
  1285.     mmr = (* pfnAcmStreamUnprepareHeader)(has, pash, fdwUnprepare);
  1286.  
  1287.     return (mmr);
  1288. }
  1289.